Partridge_All.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, University of Aarhus
All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
#ifndef partridge_allH
  #define partridge_allH
//---------------------------------------------------------------------------
 
 
struct PartridgeCommunicationData;
 
class population_attributes {
public:
  void reset();
  void copyself(population_attributes* a_population_attributes);
 
  int m_NoClutches;
  int m_NoChicksHatched;
  int m_NoChicksSixWeeks;
  int m_NoMalesSept;
  int m_NoFemalesSept;
  int m_NoChicksSept;
  int m_NoShotBirds;
  int m_NoShotFemales;
  int m_NoOldMales;
  int m_NoOldFemales;
  double m_geomeanBroodSize;
  int m_NoClutchesReplacements;
  int m_NoClutchesPredated;
  int m_NoHensPredated;
  int m_NoPairsApril;
  int m_NoFemalesApril;
  int m_NoMalesApril;
  int m_NoTerritorialFemalesApril;
  int m_NoBirdsApril;
  int m_NoMalesDec;
  int m_NoFemalesDec;
  int m_NoDeadClutches;
  int m_NoAgDeadClutches;
  int m_NoDeadChicks;
  int m_NoDeadFemales;
  int m_NoDeadMales;
  int m_NoTerritorialFemalesMay;
  int m_NoNonTerritorialFemalesMay;
  int m_NoClutchesHatched;
  int m_FemalesYear1;
  int m_NoChick1sAug;
  int m_NoChick2sAug;
  int m_NoMalesAug;
  int m_NoFemsAug ;
  int m_NoStarvedChicks;
 
  // Increment functions
  void incNoClutches() {
    m_NoClutches++;
  }
 
  void decNoClutches() {
    m_NoClutches--;
    m_NoClutchesReplacements++;
  }
 
  void incNoClutchesHatched() {
    m_NoClutchesHatched++;
  }
 
  void incNoClutchesPredated() {
    m_NoClutchesPredated++;
  }
 
  void incNoHensPredated() {
    m_NoHensPredated++;
  }
 
  void incNoChicksHatched() {
    m_NoChicksHatched++;
  }
 
  void incNoChicksSixWeeks() {
    m_NoChicksSixWeeks++;
  }
 
  void SetPairsInApril( double pa ) {
    m_NoPairsApril = ( int )pa;
  }
 
  void SetFemalesInApril( double fa ) {
    m_NoFemalesApril = ( int )fa;
  }
 
  void SetMalesInApril( double fa ) {
    m_NoMalesApril = ( int )fa;
  }
 
  void SetTerritorialFemalesInApril( double fa ) {
    m_NoTerritorialFemalesApril = ( int )fa;
  }
 
  void SetBirdsInApril( double ba ) {
    m_NoBirdsApril = ( int )ba;
  }
 
  void SetBroodGeoMean( double gm ) {
    m_geomeanBroodSize = gm;
  }
 
  void setNoChicksSept( int n ) {
    m_NoChicksSept = n;
  }
 
  void setNoFemalesSept( int n ) {
    m_NoFemalesSept = n;
  }
 
  void setNoMalesSept( int n ) {
    m_NoMalesSept = n;
  }
 
  void setNoFemalesDec( int n ) {
    m_NoFemalesDec = n;
  }
 
  void setNoMalesDec( int n ) {
    m_NoMalesDec = n;
  }
 
  void incNoDeadClutches() {
    m_NoDeadClutches++;
  }
 
  void incNoAgDeadClutches() {
    m_NoAgDeadClutches++;
  }
 
  void incNoDeadChicks() {
    m_NoDeadChicks++;
  }
 
  void incNoDeadFemales() {
    m_NoDeadFemales++;
  }
 
  void incNoDeadMales() {
    m_NoDeadMales++;
  }
 
  void incNoShotBirds() {
    m_NoShotBirds++;
  }
 
  void incNoShotFemales() {
    m_NoShotFemales++;
  }
 
  void incNoStarvedChicks() {
    m_NoStarvedChicks++;
  }
 
  void setNoOldMales( int nm ) {
    m_NoOldMales = nm;
  }
 
  void setNoOldFemales( int nf ) {
    m_NoOldFemales = nf;
  }
 
  void SetTerritorialFemalesInMay(int nf) {
    m_NoTerritorialFemalesMay=nf;
  }
 
  void SetNonTerritorialFemalesInMay(int nf) {
    m_NoNonTerritorialFemalesMay=nf;
  }
 
  void AddToChicks6wks( int ch ) {
    m_NoChicksSixWeeks += ch;
  }
 
  void setNoChick1sAug( int ch ) {
      m_NoChick1sAug = ch;
  }
 
  void setNoChick2sAug( int ch ) {
      m_NoChick2sAug= ch;
  }
 
  void setNoMalesAug( int nm ) {
      m_NoMalesAug = nm;
  }
 
  void setNoFemsAug( int nf ) {
      m_NoFemsAug = nf;
  }
  population_attributes();
  ~population_attributes();
};
 
class k_factors {
protected:
  FILE * kfactorsfile;
  double m_rk1, m_rk2, m_rk3, m_rk4, m_rk5, m_rk6;
  double m_dpk1, m_dpk2, m_dpk3, m_dpk4, m_dpk5;
 
  void reset();
  void DumpInfoDatabase1( int, int, double );
  void DumpInfoDatabase();
public:
  population_attributes* m_ThisYear;
  population_attributes* m_LastYear;
  void calcreal_1();
  void calcreal_2();
  void calcreal_3();
  void calcDickPottsk();
  //Output
  void Output_kfactors();
  void CreateInfoDatabaseFile();
  // Constructor/Destructor
  k_factors();
  ~k_factors();
};
 
 
typedef enum {
  pars_Initiation = 0,
 
  // Covey
  pars_CMoving,
 
  // Clutch
  pars_ClDeveloping, pars_ClHatching, pars_ClDying,
 
  // Chicks
  pars_ChDeveloping, pars_ChMaturing, pars_ChDying,
 
  // Male
  pars_MFlocking, pars_MFindingMate, pars_MPairing, pars_MGuardingMate, pars_MCaringForYoung, pars_MDying, pars_MFollowingMate,
 
  // Female
  pars_FFlocking, pars_FFindingTerritory, pars_FBuildingUpResources, pars_FMakingNest, pars_FLaying, pars_FStartingNewBrood,
       pars_FIncubating, pars_FCaringForYoung, pars_FAttractingMate, pars_FDying,
       // Covey
       pars_CoveyDissolve, pars_CoveyBeing,
       // Misc.
       pars_Destroy
}
Partridge_State;
 
 
typedef enum {
  pob_Clutch, pob_Chick, pob_Chick2, pob_Male, pob_Female, pob_Covey
}
Partridge_Object;
 
 
 
class Partridge_Base;
class Partridge_Clutch;
class Partridge_Nestling;
class Partridge_PreFledgeling;
class Partridge_Female;
class Partridge_Male;
class Partridge_Covey;
class Partridge_Population_Manager;
 
 
 
template < class T >
class TPartridgeList : public vector < T > {
public:
  TPartridgeList() : vector < T > () {
    ;
  }
  /* double Probe(probe_data* p_TheProbe) { return 0.0; } */
};
 
 
 
class Covey_struct {
public:
  int x;
  int y;
  Partridge_Base * first_member;
};
 
 
 
class Partridge_struct {
public:
  int x;
  int y;
  int bx;
  int by;
  Landscape * L;
  Partridge_Covey * m_covey;
  int family_counter;
 
  virtual ~Partridge_struct() {;
  }
};
 
 
 
class Clutch_struct : public Partridge_struct {
public:
  int No;
  Partridge_Female * Mum;
};
 
 
 
class Chick_struct : public Partridge_struct {
public:
  Partridge_Female * Mum;
  bool sex;
};
 
 
 
class AdultPartridge_struct : public Partridge_struct {
public:
  bool sex;
  int age;
};
 
 
 
typedef TPartridgeList < Partridge_Clutch * > Partridge_ClutchList;
 
 
class Partridge_Base : public TAnimal {
protected:
    int m_signal;
    long m_id;
    int m_family_counter;
    int m_age;
    int m_born_x;
    int m_born_y;
    bool m_UncleStatus;
    Partridge_Object m_object_type;
    Partridge_Covey * m_covey;
    Partridge_State m_state;
    virtual bool DailyMortality();
    virtual void CheckMatePointers() {;}
 
public:
    Partridge_Population_Manager * m_OurPopulationManager;
    Partridge_Object GetObjectType() {
        return m_object_type;
    }
 
    bool GetUncleStatus() {
        return m_UncleStatus;
    }
 
    void SetUncleStatus( bool a_Status ) {
        m_UncleStatus = a_Status;
    }
 
    bool PossibleMate( Partridge_Base * a_partridge );
 
    virtual bool ArePaired() { return false; }
 
    Partridge_Covey * GetCovey( void ) {
        return m_covey;
    }
    Partridge_State GetState( void ) {
        return m_state;
    }
 
    void SetState( Partridge_State a_pars ) {
        m_state = a_pars;
    }
 
    int GetFamily( void ) {
        return m_family_counter;
    }
 
    int GetAge( void ) {
        return m_age;
    }
 
    void SetAge( int a_age ) {
        m_age = a_age;
    }
 
    long GetID( void ) {
        return m_id;
    }
 
    void SetFamily( unsigned int family ) {
        m_family_counter = family;
    }
 
    void SetCovey( Partridge_Covey * a_covey ) {
        m_covey = a_covey;
    }
 
    void MakeCovey();
    void SwitchCovey( Partridge_Covey * a_covey );
 
    Partridge_Base( int a_born_x, int a_born_y, int a_x, int a_y, int a_family_counter, Partridge_Covey * a_covey,
       Landscape * a_map, Partridge_Population_Manager * a_manager );
 
    virtual ~Partridge_Base( void );
 
    virtual void CopyMyself(int a_Ptype);
};
 
 
 
class Partridge_Clutch : public Partridge_Base {
    Partridge_State ClDeveloping( void );
    void ClDying( void );
    int m_clutch_size;
    Partridge_Female * m_mother;
    bool m_underincubation;
 
public:
    virtual void Dying() {
        ClDying();
    }
    void OnStartIncubating() { m_underincubation = true; }
    virtual void BeginStep( void );
    virtual void Step( void );
    virtual void EndStep( void );
    virtual bool DailyMortality();
    virtual bool OnFarmEvent( FarmToDo event );
    void AgDying();
    void OnEaten();
    void OnGivenUp();
    void OnMumDead();
    void SetClutchSize(int cs) {
      m_clutch_size=cs;
    }
 
    int GetClutchSize( void ) {
        return m_clutch_size;
    }
 
    Partridge_Female * GetMother( void ) {
        return m_mother;
    }
 
    Partridge_Clutch( int a_x, int a_y, Partridge_Female * a_mother, Partridge_Covey * a_flock, Landscape * a_map,
       int a_num_eggs, int a_family_counter, Partridge_Population_Manager * a_manager );
 
    virtual ~Partridge_Clutch( void ) {;}
};
 
 
 
class Partridge_Chick : public Partridge_Base {
protected:
  virtual Partridge_State ChDeveloping( void );
  virtual Partridge_State ChMaturing( void );
  void ChDying( void );
  bool m_sex;
  int m_starve;
 
public:
    virtual void BeginStep( void );
    virtual void Step( void );
    virtual void EndStep( void );
    virtual bool DailyMortality();
    virtual bool OnFarmEvent( FarmToDo event );
 
    virtual void Dying() {
        ChDying();
    }
 
    void OnYouAreDead();
 
    Partridge_Chick( int a_x, int a_y, Partridge_Female * a_mother, Partridge_Covey * a_flock, Landscape * a_map, bool a_sex,
       int a_family_counter, Partridge_Population_Manager * a_manager );
 
    virtual ~Partridge_Chick( void ) {;
    }
};
 
 
 
class Partridge_Chick2 : public Partridge_Chick {
    virtual Partridge_State ChDeveloping( void );
    virtual Partridge_State ChMaturing( void );
 
public:
    virtual void BeginStep( void );
    virtual void Step( void );
    virtual void EndStep( void );
    virtual bool DailyMortality();
    virtual bool OnFarmEvent( FarmToDo event );
    Partridge_Chick2( int a_x, int a_y, Partridge_Female * a_mother, Partridge_Covey * a_flock, Landscape * a_map, bool a_sex,
       int a_family_counter, Partridge_Population_Manager * a_manager );
    virtual ~Partridge_Chick2( void ) {;}
};
 
 
 
class Partridge_Male : public Partridge_Base {
    Partridge_State MFlocking( void );
    Partridge_State MFindingMate( void );
    Partridge_State MPairing( void );
    Partridge_State MGuardingMate( void );
    Partridge_State MCaringForYoung( void );
    Partridge_State MFollowingMate( void );
    void MDying( void );
 
    int m_lifespan;
    Partridge_Female * m_MyOldWife;
    Partridge_Female * m_MyMate;
    virtual void CheckMatePointers();
 
public:
  int AmIaMember();
 
    virtual void Dying() {
        MDying();
    }
 
    virtual void BeginStep( void );
    virtual void Step( void );
    virtual void EndStep( void );
    virtual bool DailyMortality();
    virtual bool OnFarmEvent( FarmToDo event );
 
    virtual void KillThis() {
        MDying();
    }
 
    void UnSetMate( void ) {
        m_MyMate=NULL;
    }
 
    virtual bool ArePaired() {
        if (m_MyMate!=NULL) return true;
        return false;
    }
 
    Partridge_Female * GetMate( void ) {
        return m_MyMate;
    }
 
    Partridge_Male( int a_born_x, int a_born_y, int a_x, int a_y, Partridge_Covey * a_flock, Landscape * a_map,
       int a_family_counter, Partridge_Population_Manager * a_manager );
 
    virtual ~Partridge_Male( void ) {;}
 
    void OnLookAfterKids( void );
    void StartBreedingBehaviour( void );
    void OnMating( Partridge_Female * a_mate );
    void OnMateDying();
    void OnFoundATerrtitory();
    void OnChicksMatured();
    void OnChicksDead();
    void OnStoppingBreeding();
    void OnFemaleGivingUp();
    void OnMovingHome();
 
    void SetOldMate( Partridge_Female * pf) {
        m_MyOldWife=pf;
    }
 
    Partridge_Female * GetOldMate( void ) {
        return m_MyOldWife;
    }
 
    void RemoveOldMate( bool a_knockon );
};
 
 
 
class Partridge_Female : public Partridge_Base {
protected:
// Methods
  Partridge_State FFlocking( void );
  Partridge_State FPairing( void );
  Partridge_State FBuildingUpResources( void );
  Partridge_State FMakingNest( void );
  Partridge_State FLaying( void );
  Partridge_State FStartingNewBrood( bool a_waslaying );
  Partridge_State FIncubating( void );
  Partridge_State FCaringForYoung( void );
  Partridge_State FFindingTerritory( void );
  Partridge_State FAttractingMate( void );
  void FDying( void );
  virtual void CheckMatePointers();
  double GetNestingCoverDensity();
 
// Attributes
  bool m_HaveTerritory;
  bool m_clutchproduced;
  int m_clutch_size;
  int m_clutch_number;
  int m_nest_counter;
  int m_lifespan;
  int m_triggerlayingvar;
  int m_startlayingday;
  int m_buildupwait;
  Partridge_Male * m_MyMate;
  Partridge_Male * m_MyOldHusband;
  Partridge_Clutch * m_MyClutch;
 
public:
    virtual void Dying() {
        FDying();
    }
 
    virtual void BeginStep( void );
    virtual void Step( void );
    virtual void EndStep( void );
    virtual bool DailyMortality();
    virtual bool OnFarmEvent( FarmToDo event );
 
    void OnMateDying( PartridgeCommunicationData * pc_data );
    void OnClutchDeath();
    void OnClutchMown();
    void OnSetMyClutch( PartridgeCommunicationData * pc_data );
    void OnChicksMatured();
    void OnChicksDead();
    void OnMating( PartridgeCommunicationData * pc_datae );
    void OnWaitForMale();
    void OnEggsHatch();
 
    int GetClutchSize( void ) {
        return m_clutch_size;
    }
 
    Partridge_Clutch * GetClutch( void ) {
        return m_MyClutch;
    }
 
    Partridge_Male * GetMate( void ) {
        return m_MyMate;
    }
 
    void UnSetMate( void ) {
        m_MyMate=NULL;
    }
 
    virtual bool ArePaired() {
        if (m_MyMate!=NULL) return true;
        return false;
    }
 
    virtual void KillThis() {
        FDying();
    }
 
    Partridge_Male * GetOldMate( void ) {
        return m_MyOldHusband;
    }
 
    void SetOldMate( Partridge_Male * pm) {
        m_MyOldHusband=pm;
    }
 
    void RemoveOldMate(bool a_knockon) {
        if (m_MyOldHusband!= NULL) {
            if (!a_knockon) { // if it is a knock on then don't start a recursive set of calls
                m_MyOldHusband->RemoveOldMate(true);
            }
            m_MyOldHusband= NULL;
        }
    }
 
    Partridge_Female( int a_born_x, int a_born_y, int a_x, int a_y, Partridge_Covey * a_flock, Landscape * a_map,
       int a_family_counter, Partridge_Population_Manager * a_manager );
 
    virtual ~Partridge_Female( void ) {;}
 
    bool HaveTerritory( void ) {
        return m_HaveTerritory;
    }
};
#endif